package handler

import (
	"lsgfish/server/internal/dto/request"
	"lsgfish/server/internal/model"
	"lsgfish/server/internal/service"
	"lsgfish/server/internal/tool"

	"github.com/gin-gonic/gin"
)

type UserController struct {
	userService  service.UserService
	redisService tool.RedisService
}

// NewUserController 创建用户请求控制器
func NewUserController() *UserController {
	return &UserController{
		userService:  service.NewUserService(),
		redisService: tool.NewRedisService(),
	}
}

// GetUserInfo 获取用户信息
// @Summary 获取用户信息
// @Description 获取当前登录用户的详细信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Success 200 {object} tool.Response{data=model.User} "获取成功"
// @Failure 401 {object} tool.Response "未授权"
// @Failure 500 {object} tool.Response "服务器内部错误"
// @Router  /user/get [get]
func (u *UserController) GetUserInfo(c *gin.Context) {
	user, err := u.redisService.GetToken(c)
	if err != nil {
		c.Error(err)
		return
	}

	tool.Succ(c, "获取用户信息成功", user)
}

// ChangePassword 修改密码
// @Summary 修改密码
// @Description 修改当前登录用户的密码
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param password body request.PasswordRequest true "新密码"
// @Success 200 {object} tool.Response "修改成功"
// @Failure 400 {object} tool.Response "参数错误"
// @Failure 401 {object} tool.Response "未授权"
// @Failure 500 {object} tool.Response "服务器内部错误"
// @Router /user/change-password [post]
func (u *UserController) ChangePassword(c *gin.Context) {
	var req request.PasswordRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.Error(err)
		return
	}
	user, err := u.redisService.GetToken(c)
	if err != nil {
		tool.Err(c, "获取用户信息失败")
		return
	}
	hashPassword, hashErr := tool.HashPassword(req.Password)
	user.Password = hashPassword
	if hashErr != nil {
		tool.Err(c, "修改密码，加密失败")
		return
	}
	if err := u.userService.ChangePassword(user); err != nil {
		tool.Err(c, "修改密码失败")
	} else {
		tool.Succ(c, "修改密码成功")
	}
}

// GetInvitationCode 获取邀请码
// @Summary 获取邀请码
// @Description 获取当前用户的邀请码，如果没有则生成新的
// @Tags 用户管理
// @Accept json
// @Produce json
// @Success 200 {object} tool.Response{data=string} "获取成功"
// @Failure 401 {object} tool.Response "未授权"
// @Failure 500 {object} tool.Response "服务器内部错误"
// @Router /user/invit_code [get]
func (u *UserController) GetInvitationCode(c *gin.Context) {
	// 从redis中获取用户信息
	user, err := u.redisService.GetToken(c)
	if err != nil {
		c.Error(err)
		return
	} else if user.InviteCode != "" {
		tool.Succ(c, "获取邀请码成功", user.InviteCode)
		return
	} else {
		u.userService.GetUserInfo(&user)
		if user.InviteCode != "" {
			u.redisService.SetToken(user.Token, user)
			tool.Succ(c, "获取邀请码成功", user.InviteCode)
			return
		}
		if err := u.userService.GenerateInviteCode(&user); err != nil {
			c.Error(err)
			return
		}
		u.redisService.SetToken(user.Token, user)
		tool.Succ(c, "获取邀请码成功", user.InviteCode)
		return
	}
}

// PaginationList 用户列表
// @Summary 获取用户列表
// @Description 分页获取用户列表
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param page query int false "页码" default(1)
// @Param pageSize query int false "每页数量" default(10)
// @Param keyword query string false "搜索关键词"
// @Success 200 {object} tool.Response{data=response.UserPaginationResult} "获取成功"
// @Failure 400 {object} tool.Response "参数错误"
// @Failure 500 {object} tool.Response "服务器内部错误"
// @Router /user/paginationList [get]
func (u *UserController) PaginationList(c *gin.Context) {
	var params request.UserPaginationParams
	if err := c.ShouldBindQuery(&params); err != nil {
		c.Error(err)
		return
	}
	users, err := u.userService.PaginationList(params)
	if err != nil {
		tool.Err(c, err.Error())
		return
	}
	tool.Succ(c, "获取用户列表成功", users)
}

// Create 添加用户
// @Summary 添加用户
// @Description 添加新用户
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param user body model.User true "用户信息"
// @Success 200 {object} tool.Response "添加成功"
// @Failure 400 {object} tool.Response "参数错误"
// @Failure 500 {object} tool.Response "服务器内部错误"
// @Router /user/create [post]
func (u *UserController) Create(c *gin.Context) {
	var req model.User
	if err := c.ShouldBindJSON(&req); err != nil {
		tool.Err(c, "请求参数无效")
		return
	}
	if err := u.userService.Add(req); err != nil {
		tool.Err(c, err.Error())
		return
	}
	tool.Succ(c, "添加用户成功")
}

// Update 编辑用户
// @Summary 编辑用户
// @Description 更新用户信息
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param user body model.User true "用户信息"
// @Success 200 {object} tool.Response "更新成功"
// @Failure 400 {object} tool.Response "参数错误"
// @Failure 500 {object} tool.Response "服务器内部错误"
// @Router /user/update [post]
func (u *UserController) Update(c *gin.Context) {
	var req model.User
	if err := c.ShouldBindJSON(&req); err != nil {
		tool.Err(c, "请求参数无效")
		return
	}
	if err := u.userService.Update(req); err != nil {
		tool.Err(c, err.Error())
		return
	}
	tool.Succ(c, "编辑用户成功")
}

// Delete 删除用户
// @Summary 删除用户
// @Description 删除指定用户
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param id body request.UserDeleteRequest true "用户ID"
// @Success 200 {object} tool.Response "删除成功"
// @Failure 400 {object} tool.Response "参数错误"
// @Failure 500 {object} tool.Response "服务器内部错误"
// @Router /user/delete [post]
func (u *UserController) Delete(c *gin.Context) {
	var req request.UserDeleteRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		tool.Err(c, "请求参数无效")
		return
	}
	if err := u.userService.Delete(req.ID); err != nil {
		tool.Err(c, err.Error())
		return
	}
	tool.Succ(c, "删除用户成功")
}
